package org.eclipse.iota.visitor;

import org.eclipse.iota.model.Addition;
import org.eclipse.iota.model.Alternation;
import org.eclipse.iota.model.BinaryOperation;
import org.eclipse.iota.model.Boolean;
import org.eclipse.iota.model.Clause;
import org.eclipse.iota.model.Constant;
import org.eclipse.iota.model.Constraint;
import org.eclipse.iota.model.Definition;
import org.eclipse.iota.model.Division;
import org.eclipse.iota.model.Element;
import org.eclipse.iota.model.Equation;
import org.eclipse.iota.model.Existential;
import org.eclipse.iota.model.Exponentiation;
import org.eclipse.iota.model.Expression;
import org.eclipse.iota.model.Inclusion;
import org.eclipse.iota.model.Module;
import org.eclipse.iota.model.MultiOperation;
import org.eclipse.iota.model.Multiplication;
import org.eclipse.iota.model.Negation;
import org.eclipse.iota.model.Operation;
import org.eclipse.iota.model.Parameter;
import org.eclipse.iota.model.Proof;
import org.eclipse.iota.model.Property;
import org.eclipse.iota.model.Reference;
import org.eclipse.iota.model.Sequent;
import org.eclipse.iota.model.Step;
import org.eclipse.iota.model.UnaryOperation;
import org.eclipse.iota.model.Variable;

/**
 * @author Christian Krause
 * @generated NOT
 */
public abstract class AbstractIotaVisitor implements IotaVisitor {
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.iota.visitor.IotaVisitor#visit(org.eclipse.iota.model.Element)
	 */
	@Override
	public void visit(Element element) {
		if (element instanceof Module) visit((Module) element); else
		if (element instanceof Definition) visit((Definition) element); else
		if (element instanceof Alternation) visit((Alternation) element); else
		if (element instanceof Clause) visit((Clause) element); else
		if (element instanceof Constraint) visit((Constraint) element); else
		if (element instanceof Expression) visit((Expression) element); else
		if (element instanceof Proof) visit((Proof) element); else
		if (element instanceof Step) visit((Step) element); else
		if (element instanceof Variable) visit((Variable) element);
	}
	
	/**
	 * Visit a module.
	 * @param module Module to be visited.
	 */
	public void visit(Module module) {
		// No default implementation.
	}

	/**
	 * Visit a definition.
	 * @param definition Definition to be visited.
	 */
	public void visit(Definition definition) {
		if (definition instanceof Property) visit((Property) definition); else
		if (definition instanceof Sequent) visit((Sequent) definition);
	}

	/**
	 * Visit a property.
	 * @param property Property to be visited.
	 */
	public void visit(Property property) {
		// No default implementation.
	}

	/**
	 * Visit a sequent.
	 * @param sequent Sequent to be visited.
	 */
	public void visit(Sequent sequent) {
		// No default implementation.
	}

	/**
	 * Visit a proof.
	 * @param proof Proof to be visited.
	 */
	public void visit(Proof proof) {
		// No default implementation.
	}

	/**
	 * Visit a proof step.
	 * @param step Step to be visited.
	 */
	public void visit(Step step) {
		// No default implementation.
	}

	/**
	 * Visit an alternation.
	 * @param alternation Alternation to be visited.
	 */
	public void visit(Alternation alternation) {
		// No default implementation.
	}

	/**
	 * Visit a clause.
	 * @param clause Clause to be visited.
	 */
	public void visit(Clause clause) {
		// No default implementation.
	}

	/**
	 * Visit a variable
	 * @param variable Variable.
	 */
	public void visit(Variable variable) {
		if (variable instanceof Parameter) visit((Parameter) variable);
		if (variable instanceof Existential) visit((Existential) variable);
	}
	
	/**
	 * Visit a parameter.
	 * @param parameter Parameter.
	 */
	public void visit(Parameter parameter) {
		// No default action.
	}
	
	/**
	 * Visit an existential.
	 * @param existential Existential.
	 */
	public void visit(Existential existential) {
		// No default action.
	}
	
	/**
	 * Visit a constraint.
	 * @param constraint Constraint.
	 */
	public void visit(Constraint constraint) {
		if (constraint instanceof Equation) visit((Equation) constraint); else
		if (constraint instanceof Inclusion) visit((Inclusion) constraint); else
		if (constraint instanceof Boolean) visit((Boolean) constraint);
	}
	
	/**
	 * Visit an equation.
	 * @param equation Equation.
	 */
	public void visit(Equation equation) {
		// No default implementation.
	}	

	/**
	 * Visit a boolean constraint.
	 * @param constraint Boolean.
	 */
	public void visit(Boolean constraint) {
		// No default implementation.
	}

	/**
	 * Visit an inclusion.
	 * @param inclusion Inclusion.
	 */
	public void visit(Inclusion inclusion) {
		// No default implementation.
	}

	/**
	 * Visit an expression.
	 * @param expression Expression to be visited.
	 */
	public void visit(Expression expression) {
		if (expression instanceof Operation) visit((Operation) expression); else
		if (expression instanceof Constant) visit((Constant) expression); else
		if (expression instanceof Reference) visit((Reference) expression);
	}
	
	/**
	 * Visit a constant.
	 * @param constant Constant.
	 */
	public void visit(Constant constant) {
		// No default implementation.
	}
	
	/**
	 * Visit a reference.
	 * @param reference Reference.
	 */
	public void visit(Reference reference) {
		// No default implementation.
	}
	
	/**
	 * Visit an operation.
	 * @param operation Operation.
	 */
	public void visit(Operation operation) {
		if (operation instanceof UnaryOperation) visit((UnaryOperation) operation);
		if (operation instanceof BinaryOperation) visit((BinaryOperation) operation);
		if (operation instanceof MultiOperation) visit((MultiOperation) operation);
	}

	/**
	 * Visit a unary operation.
	 * @param operation Operation.
	 */
	public void visit(UnaryOperation operation) {
		if (operation instanceof Negation) visit((Negation) operation);
	}

	/**
	 * Visit a binary operation.
	 * @param operation Operation.
	 */
	public void visit(BinaryOperation operation) {
		if (operation instanceof Division) visit((Division) operation);
		if (operation instanceof Exponentiation) visit((Exponentiation) operation);
	}
	
	/**
	 * Visit a multi-operation.
	 * @param operation Operation.
	 */
	public void visit(MultiOperation operation) {
		if (operation instanceof Addition) visit((Addition) operation);
		if (operation instanceof Multiplication) visit((Multiplication) operation);
	}
	
	/**
	 * Visit an addition.
	 * @param addition Addition.
	 */
	public void visit(Addition addition) {
		// No default implementation.
	}
	
	/**
	 * Visit a negation.
	 * @param negation negation.
	 */
	public void visit(Negation negation) {
		// No default implementation.
	}
	
	/**
	 * Visit a multiplication.
	 * @param multiplication Multiplication.
	 */
	public void visit(Multiplication multiplication) {
		// No default implementation.
	}
	
	/**
	 * Visit a division.
	 * @param division division.
	 */
	public void visit(Division division) {
		// No default implementation.
	}
	
	/**
	 * Visit an exponentiation.
	 * @param exponentiation exponentiation.
	 */
	public void visit(Exponentiation exponentiation) {
		// No default implementation.
	}

}
